var QueryForm; // 查询表单
var DetailDictForm; // 字典详情表单
var addDictForm;
var updateDictForm;
var QueryWindow; // 查询窗口
var DeleteWindow;
var DictGridPanel, ZCDeleteGridPanel;
var DictStore, ZCDeleteStore; // 存放查询数据的表格的存贮变量
var selections, removeDelete; // 得到复选框选中的全部记录

/*
 * 通过查询条件连接数据库得到数据 --- 未完成
 * 
 */
var Query = function() {

	DictStore.baseParams['start'] = '0';
	DictStore.baseParams['limit'] = '15';
	DictStore.baseParams['name'] = QueryForm.form.findField('name').getValue();
	DictStore.baseParams['type'] = QueryForm.form.findField('type').getValue();

	QueryWindow.hide();
	DictStore.reload();
}
var DeleteZC = function() {
	var deleteDict = ",";
	for (var i = 0; i < ZCDeleteStore.getCount(); i++) {
		var record = ZCDeleteStore.getAt(i);
		deleteDict = deleteDict + record.get('dict_id') + ",";
	}

	Ext.Ajax.request({
				url : '/FAM/deleteDictServlet',

				success : function(response, opts) {
					var result = Ext.util.JSON.decode(response.responseText);
					if (result.success) {
						Ext.Msg.alert('成功', result.msg, function() {
									insertUserLog(5);
								}, null);
					}
				},
				failure : function() {
					insertUserLog(6)
				},
				params : {
					dict_id : deleteDict
				}
			});
}
var AccessDBtoDelete = function() {
	var length = removeDelete.length;

	for (var i = 0; i < length; i++) {
		var record = removeDelete[0];
		ZCDeleteStore.remove(record);
	}
}
var DeleteSelectedDict = function() {
	BuildDeleteZCGrid();
	BuildDeleteWindow();

	var length = selections.length;

	for (var i = 0; i < length; i++) {
		var record = selections[i];
		ZCDeleteStore.add(record);
	}

	DeleteWindow.show();
}

/*
 * 建立存放字典信息的布局
 */
var BuildDictGrid = function() {
	var SelectModel = new Ext.grid.CheckboxSelectionModel({
		listeners : {
			selectionchange : function(sm) {
				selections = DictGridPanel.getSelectionModel().getSelections();

				if (sm.getCount()) {
					DictGridPanel.removeButton.enable();
					DictGridPanel.updateButton.enable();
				} else {
					DictGridPanel.removeButton.disable();
					DictGridPanel.updateButton.disable();
				}
			}
		}
			// 单选
			// singleSelect:true
		});

	var DictColumnModel = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(),
			SelectModel, {
				header : '字典编号',
				sortable : true,
				dataIndex : 'dict_id'
			}, {
				header : '名称',
				sortable : true,
				dataIndex : 'name'
			}, {
				header : '所属类型',
				sortable : true,
				dataIndex : 'type'
			}]);
	var DictRecord = new Ext.data.Record.create([{
				name : 'dict_id'
			}, {
				name : 'name'
			}, {
				name : 'type'
			}]);

	DictStore = new Ext.data.Store({
				proxy : new Ext.data.HttpProxy({
							url : '/FAM/selectDictServlet'
						}),
				reader : new Ext.data.JsonReader({
							totalProperty : 'total',
							root : 'result'
						}, DictRecord)
			});

	DictGridPanel = new Ext.grid.GridPanel({
				width : '100%',
				height : 500,
				layout : 'fit',
				store : DictStore,
				cm : DictColumnModel,
				sm : SelectModel,
				stripeRows : true,
				loadMask : true,
				viewConfig : {
					forceFit : true
				},
				plugins : new Ext.ux.PanelResizer({
							minHeight : 100
						}),
				tbar : [{
							iconCls : 'add',
							tooltip : '添加一个字典记录',
							text : '添 加',
							handler : function() {
								addDictWindow.show();
								// Ext.getCmp('delete').hide();
								// DictColumnModel.setHidden(1, true);
							}
						}, '-', {
							iconCls : 'delete',
							id : 'delete',
							tooltip : '删除选中的字典信息',
							text : '删  除',
							ref : '../removeButton',
							disabled : true,
							handler : DeleteSelectedDict
						}, '-', {
							iconCls : 'edit',
							text : '修 改',
							ref : '../updateButton',
							disabled : true,
							tooltip : '修改选中的字典信息',
							handler : function(DictGridPanel, rowIndex, event) {
								if (selections.length > 1) {
									alert("你只能选择一条记录");
									SelectModel.clearSelections();
								} else {
									for (var i = 0; i < selections.length; i++) {

										var record = selections[i];
										changesDictWindow.show();
										updateDictForm.getForm()
												.loadRecord(record);
									}
								}

							}
						}, '-', {
							iconCls : 'query',
							text : '查  询',
							tooltip : '查询要删除的字典信息',
							handler : function() {
								QueryWindow.show();
							}
						}],
				bbar : new Ext.PagingToolbar({
							pageSize : 15,
							store : DictStore,
							displayInfo : true,
							plugins : new Ext.ux.ProgressBarPager()
						})
			});

}

var BuildDeleteZCGrid = function() {
	var SelectModel = new Ext.grid.CheckboxSelectionModel({
				listeners : {
					selectionchange : function(sm) {
						removeDelete = ZCDeleteGridPanel.getSelectionModel()
								.getSelections();

						if (sm.getCount()) {
							ZCDeleteGridPanel.removeButton.enable();
							ZCDeleteGridPanel.updateButton.enable();
						} else {
							ZCDeleteGridPanel.removeButton.disable();
							ZCDeleteGridPanel.updateButton.disable();
						}
					}
				}
			});

	var DictColumnModel = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(),
			{
				header : '字典编号',
				sortable : true,
				dataIndex : 'dict_id'
			}, {
				header : '名称',
				sortable : true,
				dataIndex : 'name'
			}, {
				header : '所属类型',
				sortable : true,
				dataIndex : 'type'
			}, SelectModel]);

	var DictRecord = new Ext.data.Record.create([{
				name : 'dict_id'
			}, {
				name : 'name'
			}, {
				name : 'type'
			}]);

	ZCDeleteStore = new Ext.data.Store({
				proxy : new Ext.data.MemoryProxy(),
				reader : new Ext.data.ArrayReader({}, DictRecord)
			});

	ZCDeleteGridPanel = new Ext.grid.GridPanel({
				width : '100%',
				autoHeight : true,
				store : ZCDeleteStore,
				cm : DictColumnModel,
				sm : SelectModel,
				stripeRows : true,
				loadMask : true,
				tbar : ['->', {
							iconCls : 'delete',
							tooltip : '移除选中要删除的字典信息',
							text : '移   除',
							ref : '../removeButton',
							disabled : true,
							handler : AccessDBtoDelete
						}]
			});
};
// var BuildUpdateDictForm = function()
{
	updateDictForm = new Ext.form.FormPanel({
				frame : true,
				labelAlign : 'right',
				labelWidht : 60,
				items : [{
					title : '信息更新',
					border : true,
					xtype : 'fieldset',
					layout : 'column',
					items : [{
								columnWidth : .5,
								xtype : 'fieldset',
								border : false,
								autoHeight : true,
								defaults : {
									width : 150,
									allowBlank : false
								},
								defaultType : 'textfield',
								items : [{
											xtype : 'hidden',
											fieldLabel : '字典ID',
											name : 'dict_id',
											disabled : true
										}]
							}, {
								columnWidth : .5,
								xtype : 'fieldset',
								border : false,
								autoHeight : true,
								defaults : {
									width : 150,
									allowBlank : false
								},
								defaultType : 'textfield',
								items : [{
											fieldLabel : '名称',
											name : 'name'
										}]
							}, {
								columnWidth : .5,
								xtype : 'fieldset',
								border : false,
								autoHeight : true,
								defaultType : 'textfield',
								defaults : {
									width : 150,
									allowBlank : false
								},
								items : [{
											fieldLabel : '所属类型',
											name : 'type',
											xtype : 'combo',
											store : new Ext.data.SimpleStore({
														fields : ['text'],
														data : [['部门'],
																['资产类别']]
													}),
											emptyText : '请选择',
											mode : 'local',
											triggerAction : 'all',
											valueField : 'text',
											displayField : 'text',
											allwoBlank : false
										}]
							}]
				}]
			});
};
// var BuildAddDictForm = function()
{
	addDictForm = new Ext.form.FormPanel({
				frame : true,
				width : '100%',
				labelAlign : 'right',
				labelWidht : 60,
				items : [{
					title : '信息添加',
					border : true,
					xtype : 'fieldset',
					layout : 'column',
					items : [{
								columnWidth : .5,
								xtype : 'fieldset',
								border : false,
								autoHeight : true,
								defaults : {
									width : 150,
									allowBlank : false
								},
								defaultType : 'textfield',
								items : [{
											fieldLabel : '名称',
											name : 'name'
										}]
							}, {
								columnWidth : .5,
								xtype : 'fieldset',
								border : false,
								autoHeight : true,
								defaultType : 'textfield',
								defaults : {
									width : 150,
									allowBlank : false
								},
								items : [{
											fieldLabel : '所属类型',
											name : 'type',
											xtype : 'combo',
											store : new Ext.data.SimpleStore({
														fields : ['text'],
														data : [['部门'],
																['资产类别']]
													}),
											emptyText : '请选择',
											mode : 'local',
											triggerAction : 'all',
											valueField : 'text',
											displayField : 'text',
											allwoBlank : false
										}]
							}]
				}]
			});
};

/*
 * 建立查询字典信息的布局
 */
var BuildQueryForm = function() {
	QueryForm = new Ext.form.FormPanel({
		labelAlign : 'right',
		labelWidth : 70,
		width : '100%',
		bodyStyle : 'padding:20px 10px;',
		items : [{
			layout : 'column',
			border : false,
			items : [{
						bodyStyle : 'padding-top:5px',
						columnWidth : .5,
						border : false,
						layout : 'form',
						defaults : {
							width : 130
						},
						defaultType : 'textfield',
						items : [{
									fieldLabel : '名称',
									name : 'name',
									xtype : 'combo',
									store : new Ext.data.Store({
												proxy : new Ext.data.HttpProxy(
														{
															url : '/FAM/getDictName'
														}),// 从数据库取数据
												reader : new Ext.data.JsonReader(
														{
															root : 'dictName'
														}, ['name']), // 匹配数据库中的字段
												autoLoad : false
											}),
									emptyText : '请选择',
									mode : 'remote',
									triggerAction : 'all',
									valueField : 'name',
									displayField : 'name'
								}]
					}, {
						bodyStyle : 'padding-top:5px',
						columnWidth : .5,
						border : false,
						layout : 'form',
						style : 'margin-left: 15px;',
						defaults : {
							width : 130
						},
						defaultType : 'textfield',
						items : [{
									fieldLabel : '所属类型',
									name : 'type',
									xtype : 'combo',
									store : new Ext.data.SimpleStore({
												fields : ['text'],
												data : [['部门'], ['资产类别']]
											}),
									emptyText : '请选择',
									mode : 'local',
									triggerAction : 'all',
									valueField : 'text',
									displayField : 'text',
									allwoBlank : false
								}]
					}]
		}]
	})
}

/*
 * 建立查询字典信息的窗口 --- 存放QueryForm
 */
var BuildQueryWindow = function() {
	QueryWindow = new Ext.Window({
				title : '~ 查询窗口 (请选择查询条件)~',
				width : 500,
				heigth : 400,
				modal : true,
				resizable : false,
				closeAction : 'hide',
				items : [QueryForm],
				buttons : [{
							iconCls : 'query',
							text : '查 询',
							handler : Query
						}, {
							iconCls : 'empty',
							text : '清 空',
							handler : function() {
								QueryForm.getForm().reset();
							}
						}],
				buttonAlign : 'center'
			})
}

/*
 * 建立存放详细字典信息的布局
 */

var BuildDeleteWindow = function() {
	DeleteWindow = new Ext.Window({
				title : '~ 删除窗口 (已选中要删除的字典信息)~',
				modal : true,
				closeAction : 'hide',
				resizable : false,
				items : [ZCDeleteGridPanel],
				buttons : [{
							iconCls : 'ok',
							text : '确 定',
							handler : DeleteZC
						}, {
							iconCls : 'cancel',
							text : '取 消',
							handler : function() {
								DeleteWindow.hide();
							}
						}],
				buttonAlign : 'center'
			})
}
var BuildLayout = function() {
	new Ext.Viewport({
				layout : 'border',
				items : [{
							region : 'center',
							layout : 'fit',
							items : [DictGridPanel]
						}]
			})
};
var addDictWindow = new Ext.Window({
			title : '添加字典信息(添加模式)',
			width : 600,
			height : 170,
			modal : true,
			closeAction : 'hide',
			resizable : false,
			items : [addDictForm],
			buttons : [{
				iconCls : 'save',
				text : '保 存',
				handler : function() {
					if (!addDictForm.getForm().isValid()) {
						return;
					} else {
						addDictForm.getForm().submit({
							waitMsg : '正在添加.....',
							url : '/FAM/addDictServlet', // 提交数据到数据库
							success : function(f, action) {
								addDictWindow.hide();
								if (action.result.success) {
									if(DictStore > 0)
									    DictStore.reload();
									else{
										DictStore.baseParams['start'] = '0';
										DictStore.baseParams['limit'] = '15';
										DictStore.baseParams['name'] = '';
										DictStore.baseParams['type'] = '';
										DictStore.reload();
									}
									Ext.Msg.alert('成功', action.result.msg,
											function() {
												addDictForm.getForm().reset();
											}, null);
									insertUserLog(1);
								} else
									insertUserLog(2);
							}
						})
					}
				}
			}, {
				iconCls : 'empty',
				text : '清 空',
				handler : function() {
					addDictForm.getForm().reset();
				}
			}, {
				iconCls : 'back',
				text : '返 回',
				handler : function() {
					addDictWindow.hide();
				}
			}],
			buttonAlign : 'right'
		})
var changesDictWindow = new Ext.Window({
			title : '修改字典信息(修改模式)',
			width : 580,
			autoHeigth : true,
			modal : true,
			closeAction : 'hide',
			resizable : false,
			closeAction : 'hide',
			items : [updateDictForm],
			buttons : [{
				iconCls : 'update',
				text : '修 改',
				disabled : false,
				handler : function() {
					if (!updateDictForm.getForm().isValid()) {
						return;
					} else {
						var dict_id = updateDictForm.form.findField('dict_id')
								.getValue()
						var name = updateDictForm.form.findField('name')
								.getValue();
						var type = updateDictForm.form.findField('type')
								.getValue()
						Ext.Ajax.request({
									waitMsg : '正在修改数据.....',
									url : '/FAM/updataDictServlet',
									success : function(response, opts) {
										var result = Ext.util.JSON
												.decode(response.responseText);
										if (result.success) {
											Ext.Msg.alert('成功', result.msg,
													function() {
														updateDictForm
																.getForm()
																.reset();
														insertUserLog(3); // 修改字典信息成功，记录用户日志
														// ，1
													// --
													// XX管理员修改字典信息成功
												}, null);
										}
									},
									failure : function() {
										insertUserLog(4);
									},
									params : {
										dict_id : dict_id,
										name : name,
										type : type
									}
								});
					}
				}
			}, {
				iconCls : 'empty',
				text : '清空',
				handler : function() {
					updateDictForm.getForm().reset();
				}
			}, {
				iconCls : 'back',
				text : '返回',
				handler : function() {
					changesDictWindow.hide();
				}
			}],
			buttonAlign : 'right'
		})
/*
 * 字典信息成功添加 参数 1 -- 添加成功 2 -- 添加失败 记录用户日志
 */
var insertUserLog = function(flag) {
	if (flag == 1) {
		Ext.Ajax.request({
					url : '/FAM/insertLog',
					success : Ext.emptyFn(),
					failure : Ext.emptyFn(),
					params : {
						data : 1,
						type : "添加字典信息",
						obj : "字典"
					}
				});
	} else if (flag == 2) {
		Ext.Ajax.request({
					url : '/FAM/insertLog',
					success : Ext.emptyFn(),
					failure : Ext.emptyFn(),
					params : {
						data : 0,
						type : "添加字典信息"
					}
				});
	} else if (flag == 3) {
		Ext.Ajax.request({
					url : '/FAM/insertLog',
					success : Ext.emptyFn(),
					failure : Ext.emptyFn(),
					params : {
						data : 1,
						type : "修改字典信息",
						obj : "字典"
					}
				});
		changesDictWindow.hide();
		DictStore.reload();
	} else if (flag == 4) {
		Ext.Ajax.request({
					url : '/FAM/insertLog',
					success : Ext.emptyFn(),
					failure : Ext.emptyFn(),
					params : {
						data : 0,
						type : "修改字典信息",
						obj : "字典"
					}
				});
	} else if (flag == 5) {
		Ext.Ajax.request({
					url : '/FAM/insertLog',
					success : Ext.emptyFn(),
					failure : Ext.emptyFn(),
					params : {
						data : 1,
						type : "删除字典信息",
						obj : "字典"
					}
				});
		DeleteWindow.hide();
		DictStore.reload();
	} else if (flag == 6) {
		Ext.Ajax.request({
					url : '/FAM/insertLog',
					success : Ext.emptyFn(),
					failure : Ext.emptyFn(),
					params : {
						data : 0,
						type : "删除字典信息",
						obj : "字典"
					}
				});
	}
}
/*
 * 初始化各个界面的布局
 */
var init = function() {
	Ext.QuickTips.init();
	Ext.form.Field.prototype.msgTarget = 'side';
	BuildDictGrid();
	BuildQueryForm();
	BuildQueryWindow();
	BuildLayout();
}

Ext.onReady(init);